// Package config 实现了配置管理功能
//
// 配置存储说明：
// 1. 存储结构
//   - 使用 SQLite 数据库存储配置项
//   - 表名：configs
//   - 字段：
//   - id: 自增主键
//   - key: 配置键名，使用点号分隔的路径格式
//   - value: JSON 格式的配置值
//   - updated_at: 最后更新时间
//
// 2. 键名规则
//   - 使用点号（.）分隔的路径格式表示配置层级
//   - 第一级表示主要分类，如：monitor、mqtt、bluetooth
//   - 第二级表示子分类，如：power_adjust、temp_threshold
//   - 第三级表示具体配置项，如：duty_max、duty_min
//     示例：
//   - monitor.power_adjust.duty_max = 100
//   - monitor.temp_threshold.high_fatal = 85
//   - mqtt.broker_address = "mqtt://server:1883"
//
// 3. 值存储
//   - 所有值以 JSON 格式序列化后存储
//   - 数值类型：直接存储数字，如 100, 3.14
//   - 字符串：带引号存储，如 "mqtt://server:1883"
//   - 布尔值：存储 true 或 false
//   - 数组：存储 JSON 数组，如 ["topic1", "topic2"]
//
// 4. 缓存机制
//   - 首次访问时加载所有配置到内存
//   - 更新操作同步更新缓存和数据库
//   - 支持缓存重载和清理
//
// 5. 配置操作
//   - GetAllConfigs：获取所有配置
//   - UpdateAllConfigs：更新全部配置（替换式更新）
//   - UpdateConfigItem：更新单条配置（增量更新）
//
// 6. 事务处理
//   - 所有写操作都在事务中执行
//   - 确保数据一致性
//   - 失败时自动回滚
//
// 7. 错误处理
//   - 详细的错误信息
//   - 包含操作类型和键名
//   - 完整的错误链跟踪
//
// 8. 日志记录
//   - 记录所有关键操作
//   - 包含操作结果和影响范围
//   - 按分类展示配置内容
package config

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"gitee.com/rw555/fdsmastergo/pkg/logger"
	"go.uber.org/zap"
)

// Config 配置项模型
type Config struct {
	ID        int64     `json:"id"`         // 配置项ID
	Key       string    `json:"key"`        // 配置键名，使用点号分隔，如：monitor.power_adjust.duty_max
	Value     string    `json:"value"`      // 配置值
	UpdatedAt time.Time `json:"updated_at"` // 最后更新时间
}

// AutoModeSession 自动模式运行记录
type AutoModeSession struct {
	ID        int64     `json:"id"`
	StartTime time.Time `json:"start_time"`
	EndTime   time.Time `json:"end_time"`
	CreatedAt time.Time `json:"created_at"`
}

// ConfigStorage 配置存储接口
type ConfigStorage interface {
	// CloseDB 关闭数据库连接
	CloseDB() error

	// UpdateAllConfigs 更新系统配置
	UpdateAllConfigs(config map[string]interface{}) error

	// UpdateConfigItem 更新单条配置
	UpdateConfigItem(key string, value interface{}) error

	// GetAllConfigs 获取所有配置项
	GetAllConfigs() (map[string]interface{}, error)

	// SaveAutoModeSession 保存自动模式会话记录
	SaveAutoModeSession(startTime, endTime time.Time) error

	// GetAutoModeSessions 获取自动模式会话记录
	GetAutoModeSessions(startDate, endDate time.Time) ([]AutoModeSession, error)

	// GetAutoModeTotalTime 获取自动模式总运行时长（分钟）
	GetAutoModeTotalTime() (int, error)
}

// SQLiteConfigStorage SQLite配置存储实现
type SQLiteConfigStorage struct {
	db     *sql.DB
	cache  map[string]interface{} // 配置缓存
	loaded bool                   // 缓存是否已加载
}

func initDB() (*sql.DB, error) {
	// 获取可执行文件所在目录
	exePath, err := os.Executable()
	if err != nil {
		return nil, fmt.Errorf("获取可执行文件路径失败: %w", err)
	}
	dbPath := filepath.Join(filepath.Dir(exePath), "data")
	dbname := "config.db"
	// 确保数据目录存在
	if err := os.MkdirAll(dbPath, 0755); err != nil {
		return nil, fmt.Errorf("创建数据目录失败: %w", err)
	}

	db, err := sql.Open("sqlite", filepath.Join(dbPath, dbname))
	if err != nil {
		return nil, err
	}

	return db, nil
}

// NewSQLiteConfigStorage 创建SQLite配置存储
func NewSQLiteConfigStorage() (*SQLiteConfigStorage, error) {
	db, err := initDB()
	if err != nil {
		return nil, fmt.Errorf("初始化数据库失败: %w", err)
	}

	// 创建配置表
	_, err = db.Exec(`CREATE TABLE IF NOT EXISTS configs (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		key TEXT UNIQUE NOT NULL,
		value TEXT NOT NULL,
		updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
	)`)
	if err != nil {
		db.Close()
		return nil, fmt.Errorf("创建配置表失败: %w", err)
	}

	return &SQLiteConfigStorage{
		db:     db,
		cache:  make(map[string]interface{}),
		loaded: false,
	}, nil
}

// loadCache 加载所有配置到缓存
func (s *SQLiteConfigStorage) loadCache() error {
	if s.loaded {
		return nil
	}

	// 查询所有配置
	rows, err := s.db.Query("SELECT key, value FROM configs")
	if err != nil {
		return fmt.Errorf("查询配置失败: %w", err)
	}
	defer rows.Close()

	// 清空现有缓存
	s.cache = make(map[string]interface{})

	// 加载所有配置到缓存
	for rows.Next() {
		var key, value string
		if err := rows.Scan(&key, &value); err != nil {
			return fmt.Errorf("读取配置失败: %w", err)
		}

		// 解析JSON值
		var parsedValue interface{}
		if err := json.Unmarshal([]byte(value), &parsedValue); err != nil {
			return fmt.Errorf("解析配置值失败 [%s]: %w", key, err)
		}

		s.cache[key] = parsedValue
	}

	if err := rows.Err(); err != nil {
		return fmt.Errorf("遍历配置失败: %w", err)
	}

	s.loaded = true
	return nil
}

// UpdateAllConfigs 更新系统配置
func (s *SQLiteConfigStorage) UpdateAllConfigs(config map[string]interface{}) error {
	// 开启事务
	tx, err := s.db.Begin()
	if err != nil {
		return fmt.Errorf("开启事务失败: %w", err)
	}
	defer tx.Rollback()

	// 清空现有配置
	_, err = tx.Exec("DELETE FROM configs")
	if err != nil {
		return fmt.Errorf("清空配置失败: %w", err)
	}

	// 准备插入语句
	stmt, err := tx.Prepare("INSERT INTO configs (key, value) VALUES (?, ?)")
	if err != nil {
		return fmt.Errorf("准备SQL语句失败: %w", err)
	}
	defer stmt.Close()

	// 清空缓存
	s.cache = make(map[string]interface{})

	// 插入新配置
	for key, value := range config {
		// 序列化值为JSON
		jsonValue, err := json.Marshal(value)
		if err != nil {
			return fmt.Errorf("序列化配置值失败 [%s]: %w", key, err)
		}

		// 插入数据库
		if _, err := stmt.Exec(key, string(jsonValue)); err != nil {
			return fmt.Errorf("插入配置失败 [%s]: %w", key, err)
		}

		// 更新缓存
		s.cache[key] = value
	}

	// 提交事务
	if err := tx.Commit(); err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}

	s.loaded = true
	return nil
}

// GetAllConfigs 获取所有配置项
func (s *SQLiteConfigStorage) GetAllConfigs() (map[string]interface{}, error) {
	// 确保缓存已加载
	if err := s.loadCache(); err != nil {
		return nil, err
	}

	// 返回缓存的副本
	result := make(map[string]interface{}, len(s.cache))
	for k, v := range s.cache {
		result[k] = v
	}

	return result, nil
}

// CloseDB 关闭数据库连接
func (s *SQLiteConfigStorage) CloseDB() error {
	s.cache = nil
	s.loaded = false
	return s.db.Close()
}

// loadDefaultConfig 从默认配置文件加载配置
func loadDefaultConfig() (map[string]interface{}, error) {
	// 获取可执行文件所在目录
	exePath, err := os.Executable()
	if err != nil {
		return nil, fmt.Errorf("获取可执行文件路径失败: %w", err)
	}

	// 读取默认配置文件（必须在可执行文件同级目录）
	configPath := filepath.Join(filepath.Dir(exePath), "default_configs.json")

	// 检查配置文件是否存在
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		logger.SystemError("默认配置文件不存在，这是一个致命错误",
			zap.String("path", configPath),
			zap.String("说明", "default_configs.json 必须位于可执行文件同级目录"))
		return nil, fmt.Errorf("默认配置文件不存在: %s", configPath)
	}

	// 读取配置文件
	jsonData, err := os.ReadFile(configPath)
	if err != nil {
		return nil, fmt.Errorf("读取默认配置文件失败: %w", err)
	}

	// 解析JSON
	var config map[string]interface{}
	if err := json.Unmarshal(jsonData, &config); err != nil {
		return nil, fmt.Errorf("解析默认配置文件失败: %w", err)
	}

	logger.SystemInfo("默认配置文件加载成功")
	return config, nil
}

// NewConfigStorage 创建新的配置存储实例
func NewConfigStorage() (ConfigStorage, error) {
	storage, err := NewSQLiteConfigStorage()
	if err != nil {
		return nil, err
	}

	// 检查并创建自动模式运行记录表
	if err := storage.createAutoModeSessionsTable(); err != nil {
		logger.SystemError("创建自动模式运行记录表失败", zap.Error(err))
	}

	// 检查并创建自动模式总运行时长表
	if err := storage.createAutoModeTotalTimeTable(); err != nil {
		logger.SystemError("创建自动模式总运行时长表失败", zap.Error(err))
	}

	// 检查是否已有配置
	configs, err := storage.GetAllConfigs()
	if err == nil && len(configs) > 0 {
		logger.SystemInfo("配置已存在，使用数据库中的配置")
		printConfigsByCategory(configs)

		return storage, nil
	}

	// 加载默认配置
	config, err := loadDefaultConfig()
	if err != nil {
		return nil, err
	}

	// 使用UpdateSystemConfig更新所有配置
	if err := storage.UpdateAllConfigs(config); err != nil {
		return nil, err
	}

	logger.SystemInfo("初始化默认配置成功")
	printConfigsByCategory(config)
	return storage, nil
}

// printConfigsByCategory 按分类打印配置项
func printConfigsByCategory(configs map[string]interface{}) {
	// 按前缀分组
	categories := make(map[string]map[string]interface{})

	for key, value := range configs {
		parts := strings.Split(key, ".")
		if len(parts) > 0 {
			category := parts[0]
			if _, exists := categories[category]; !exists {
				categories[category] = make(map[string]interface{})
			}
			categories[category][key] = value
		}
	}

	// 按分类打印
	for category, items := range categories {
		logger.SystemInfo(fmt.Sprintf("【%s】配置项：", category))
		// 对每个分类中的配置项进行排序
		keys := make([]string, 0, len(items))
		for k := range items {
			keys = append(keys, k)
		}
		sort.Strings(keys)

		// 打印排序后的配置项
		for _, key := range keys {
			logger.SystemInfo(fmt.Sprintf("  %s = %v", key, items[key]))
		}
	}
}

// UpdateConfigItem 更新单条配置
func (s *SQLiteConfigStorage) UpdateConfigItem(key string, value interface{}) error {
	// 先获取原始配置项，检查类型
	var originalValue interface{}
	var needTypeConversion bool = false

	if s.loaded {
		// 如果缓存已加载，从缓存中获取
		if origVal, exists := s.cache[key]; exists {
			originalValue = origVal
			needTypeConversion = true
		}
	} else {
		// 从数据库中获取
		var jsonValue string
		err := s.db.QueryRow("SELECT value FROM configs WHERE key = ?", key).Scan(&jsonValue)
		if err == nil {
			// 解析原始值
			var origVal interface{}
			if err := json.Unmarshal([]byte(jsonValue), &origVal); err == nil {
				originalValue = origVal
				needTypeConversion = true
			}
		}
	}

	// 如果找到原始值，尝试进行类型转换
	if needTypeConversion {
		switch origVal := originalValue.(type) {
		case float64:
			// 如果原始值是数值类型，尝试将新值转换为数值
			if strVal, ok := value.(string); ok {
				var floatVal float64
				if _, err := fmt.Sscanf(strVal, "%f", &floatVal); err == nil {
					value = floatVal
					logger.SystemInfo("配置值类型转换",
						zap.String("key", key),
						zap.String("from", strVal),
						zap.Float64("to", floatVal),
						zap.Float64("original", origVal))
				}
			}
		case int:
			// 如果原始值是整数类型，尝试将新值转换为整数
			if strVal, ok := value.(string); ok {
				var intVal int
				if _, err := fmt.Sscanf(strVal, "%d", &intVal); err == nil {
					value = intVal
					logger.SystemInfo("配置值类型转换",
						zap.String("key", key),
						zap.String("from", strVal),
						zap.Int("to", intVal),
						zap.Int("original", origVal))
				}
			}
		case bool:
			// 如果原始值是布尔类型，尝试将新值转换为布尔值
			if strVal, ok := value.(string); ok {
				if strVal == "true" || strVal == "1" {
					value = true
					logger.SystemInfo("配置值类型转换",
						zap.String("key", key),
						zap.String("from", strVal),
						zap.Bool("to", true),
						zap.Bool("original", origVal))
				} else if strVal == "false" || strVal == "0" {
					value = false
					logger.SystemInfo("配置值类型转换",
						zap.String("key", key),
						zap.String("from", strVal),
						zap.Bool("to", false),
						zap.Bool("original", origVal))
				}
			}
		}
	}

	// 序列化值为JSON
	jsonValue, err := json.Marshal(value)
	if err != nil {
		return fmt.Errorf("序列化配置值失败 [%s]: %w", key, err)
	}

	// 开启事务
	tx, err := s.db.Begin()
	if err != nil {
		return fmt.Errorf("开启事务失败: %w", err)
	}
	defer tx.Rollback()

	// 更新配置项
	result, err := tx.Exec("UPDATE configs SET value = ?, updated_at = CURRENT_TIMESTAMP WHERE key = ?",
		string(jsonValue), key)
	if err != nil {
		return fmt.Errorf("更新配置失败 [%s]: %w", key, err)
	}

	// 检查是否存在该配置项
	rows, err := result.RowsAffected()
	if err != nil {
		return fmt.Errorf("获取更新结果失败: %w", err)
	}

	// 如果配置项不存在，则插入
	if rows == 0 {
		_, err = tx.Exec("INSERT INTO configs (key, value, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
			key, string(jsonValue))
		if err != nil {
			return fmt.Errorf("插入配置失败 [%s]: %w", key, err)
		}
	}

	// 提交事务
	if err := tx.Commit(); err != nil {
		return fmt.Errorf("提交事务失败: %w", err)
	}

	// 更新缓存
	if s.loaded {
		s.cache[key] = value
	}

	logger.SystemInfo("更新单条配置成功",
		zap.String("key", key),
		zap.Any("value", value))

	return nil
}

// createAutoModeSessionsTable 创建自动模式运行记录表
func (s *SQLiteConfigStorage) createAutoModeSessionsTable() error {
	// 检查表是否存在
	var tableName string
	query := "SELECT name FROM sqlite_master WHERE type='table' AND name='auto_mode_sessions'"
	err := s.db.QueryRow(query).Scan(&tableName)

	// 如果表不存在，则创建
	if err != nil {
		if err == sql.ErrNoRows {
			logger.SystemInfo("自动模式运行记录表不存在，开始创建")

			// 创建表
			createTableSQL := `
			CREATE TABLE auto_mode_sessions (
				id INTEGER PRIMARY KEY AUTOINCREMENT,
				start_time TIMESTAMP NOT NULL,
				end_time TIMESTAMP NOT NULL,
				created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
			);`

			_, err := s.db.Exec(createTableSQL)
			if err != nil {
				return fmt.Errorf("创建自动模式运行记录表失败: %w", err)
			}

			logger.SystemInfo("自动模式运行记录表创建成功")
			return nil
		}
		return fmt.Errorf("检查自动模式运行记录表是否存在失败: %w", err)
	}

	logger.SystemInfo("自动模式运行记录表已存在")
	return nil
}

// GetAutoModeSessions 获取指定时间段内的自动模式运行记录
func (s *SQLiteConfigStorage) GetAutoModeSessions(startDate, endDate time.Time) ([]AutoModeSession, error) {
	query := `
	SELECT id, start_time, end_time, created_at
	FROM auto_mode_sessions
	WHERE start_time >= ? AND end_time <= ?
	ORDER BY start_time DESC
	`

	rows, err := s.db.Query(query, startDate.Format("2006-01-02 15:04:05"), endDate.Format("2006-01-02 15:04:05"))
	if err != nil {
		return nil, fmt.Errorf("查询自动模式运行记录失败: %w", err)
	}
	defer rows.Close()

	var sessions []AutoModeSession
	for rows.Next() {
		var session AutoModeSession
		var startTimeStr, endTimeStr, createdAtStr string

		err := rows.Scan(&session.ID, &startTimeStr, &endTimeStr, &createdAtStr)
		if err != nil {
			return nil, fmt.Errorf("解析自动模式运行记录失败: %w", err)
		}

		// 解析时间字符串
		var err1, err2, err3 error
		session.StartTime, _, err1 = parseTimeWithMultipleFormats(startTimeStr)
		session.EndTime, _, err2 = parseTimeWithMultipleFormats(endTimeStr)
		session.CreatedAt, _, err3 = parseTimeWithMultipleFormats(createdAtStr)

		// 检查是否有解析错误
		if err1 != nil || err2 != nil || err3 != nil {
			logger.SystemWarn("解析时间格式失败",
				zap.Error(err1),
				zap.Error(err2),
				zap.Error(err3),
				zap.String("start_time", startTimeStr),
				zap.String("end_time", endTimeStr),
				zap.String("created_at", createdAtStr))
			// 尝试继续处理，不返回错误
		}

		sessions = append(sessions, session)
	}

	if err = rows.Err(); err != nil {
		return nil, fmt.Errorf("遍历自动模式运行记录失败: %w", err)
	}

	return sessions, nil
}

// SaveAutoModeSession 保存自动模式运行记录（如果起始时间相同则更新）
func (s *SQLiteConfigStorage) SaveAutoModeSession(startTime, endTime time.Time) error {
	var id int64
	query := `SELECT id FROM auto_mode_sessions WHERE start_time = ?`
	err := s.db.QueryRow(query, startTime.Format("2006-01-02 15:04:05")).Scan(&id)

	// 计算会话时长（分钟）
	durationMinutes := int(endTime.Sub(startTime).Minutes())
	if durationMinutes < 0 {
		durationMinutes = 0 // 防止负值
	}

	if err != nil {
		if err == sql.ErrNoRows {
			insertSQL := `
			INSERT INTO auto_mode_sessions (start_time, end_time)
			VALUES (?, ?)
			`
			_, err := s.db.Exec(insertSQL,
				startTime.Format("2006-01-02 15:04:05"),
				endTime.Format("2006-01-02 15:04:05"))

			if err != nil {
				return fmt.Errorf("插入自动模式运行记录失败: %w", err)
			}

			// 更新总时长
			err = s.addAutoModeTotalTime(durationMinutes)
			if err != nil {
				logger.SystemError("更新自动模式总运行时长失败", zap.Error(err))
				// 不返回错误，继续执行
			}

			logger.SystemInfo("自动模式运行记录已添加",
				zap.String("开始时间", startTime.Format("2006-01-02 15:04:05")),
				zap.String("结束时间", endTime.Format("2006-01-02 15:04:05")),
				zap.Int("持续时间(分钟)", durationMinutes))

			return nil
		} else {
			return fmt.Errorf("检查自动模式运行记录是否存在失败: %w", err)
		}
	}

	// 获取原始结束时间
	var oldEndTimeStr string
	err = s.db.QueryRow("SELECT end_time FROM auto_mode_sessions WHERE id = ?", id).Scan(&oldEndTimeStr)
	if err != nil {
		return fmt.Errorf("获取原始结束时间失败: %w", err)
	}

	// 解析原始结束时间，尝试多种格式
	oldEndTime, _, err := parseTimeWithMultipleFormats(oldEndTimeStr)
	if err != nil {
		return fmt.Errorf("解析原始结束时间失败: %w", err)
	}

	// 计算原始会话时长（分钟）
	oldDurationMinutes := int(oldEndTime.Sub(startTime).Minutes())
	if oldDurationMinutes < 0 {
		oldDurationMinutes = 0 // 防止负值
	}

	// 计算时长差值
	durationDiff := durationMinutes - oldDurationMinutes

	// 存在，更新记录
	updateSQL := `
	UPDATE auto_mode_sessions
	SET end_time = ? WHERE id = ?
	`
	_, err = s.db.Exec(updateSQL,
		endTime.Format("2006-01-02 15:04:05"), id)
	if err != nil {
		return fmt.Errorf("更新自动模式运行记录失败: %w", err)
	}

	// 如果时长有变化，更新总时长
	if durationDiff != 0 {
		err = s.addAutoModeTotalTime(durationDiff)
		if err != nil {
			logger.SystemError("更新自动模式总运行时长失败", zap.Error(err))
			// 不返回错误，继续执行
		}
	}

	logger.SystemInfo("自动模式运行记录已更新",
		zap.Int64("ID", id),
		zap.String("开始时间", startTime.Format("2006-01-02 15:04:05")),
		zap.String("结束时间", endTime.Format("2006-01-02 15:04:05")),
		zap.Int("持续时间(分钟)", durationMinutes),
		zap.Int("最近时长变化", durationDiff))

	return nil
}

// createAutoModeTotalTimeTable 创建自动模式总运行时长表
func (s *SQLiteConfigStorage) createAutoModeTotalTimeTable() error {
	// 检查表是否存在
	var tableName string
	query := "SELECT name FROM sqlite_master WHERE type='table' AND name='auto_mode_total_time'"
	err := s.db.QueryRow(query).Scan(&tableName)

	// 如果表不存在，则创建
	if err != nil {
		if err == sql.ErrNoRows {
			logger.SystemInfo("自动模式总运行时长表不存在，开始创建")

			// 创建表
			createTableSQL := `
			CREATE TABLE auto_mode_total_time (
				id INTEGER PRIMARY KEY AUTOINCREMENT,
				total_minutes INTEGER NOT NULL DEFAULT 0,
				last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
			);`

			_, err := s.db.Exec(createTableSQL)
			if err != nil {
				return fmt.Errorf("创建自动模式总运行时长表失败: %w", err)
			}

			// 初始化一条记录
			_, err = s.db.Exec("INSERT INTO auto_mode_total_time (total_minutes) VALUES (0)")
			if err != nil {
				return fmt.Errorf("初始化自动模式总运行时长记录失败: %w", err)
			}

			logger.SystemInfo("自动模式总运行时长表创建成功")
			return nil
		}
		return fmt.Errorf("检查自动模式总运行时长表是否存在失败: %w", err)
	}

	logger.SystemInfo("自动模式总运行时长表已存在")
	return nil
}

// GetAutoModeTotalTime 获取自动模式总运行时长（分钟）
func (s *SQLiteConfigStorage) GetAutoModeTotalTime() (int, error) {
	var totalMinutes int
	query := "SELECT total_minutes FROM auto_mode_total_time ORDER BY id DESC LIMIT 1"
	err := s.db.QueryRow(query).Scan(&totalMinutes)
	if err != nil {
		return 0, fmt.Errorf("获取自动模式总运行时长失败: %w", err)
	}
	return totalMinutes, nil
}

// updateAutoModeTotalTime 更新自动模式总运行时长
func (s *SQLiteConfigStorage) updateAutoModeTotalTime(minutes int) error {
	// 获取最新记录的ID
	var id int64
	query := "SELECT id FROM auto_mode_total_time ORDER BY id DESC LIMIT 1"
	err := s.db.QueryRow(query).Scan(&id)
	if err != nil {
		if err == sql.ErrNoRows {
			// 如果没有记录，创建一条新记录
			_, err := s.db.Exec("INSERT INTO auto_mode_total_time (total_minutes) VALUES (?)", minutes)
			if err != nil {
				return fmt.Errorf("创建自动模式总运行时长记录失败: %w", err)
			}
			logger.SystemInfo("创建自动模式总运行时长记录成功", zap.Int("总分钟数", minutes))
			return nil
		}
		return fmt.Errorf("获取自动模式总运行时长记录ID失败: %w", err)
	}

	// 更新记录
	_, err = s.db.Exec("UPDATE auto_mode_total_time SET total_minutes = ?, last_updated = CURRENT_TIMESTAMP WHERE id = ?", minutes, id)
	if err != nil {
		return fmt.Errorf("更新自动模式总运行时长失败: %w", err)
	}

	return nil
}

// addAutoModeTotalTime 增加自动模式总运行时长
func (s *SQLiteConfigStorage) addAutoModeTotalTime(minutes int) error {
	// 获取当前总时长
	currentTotal, err := s.GetAutoModeTotalTime()
	if err != nil {
		return fmt.Errorf("获取当前自动模式总运行时长失败: %w", err)
	}

	// 计算新的总时长
	newTotal := currentTotal + minutes

	// 更新总时长
	err = s.updateAutoModeTotalTime(newTotal)
	if err != nil {
		return fmt.Errorf("更新自动模式总运行时长失败: %w", err)
	}

	return nil
}

// parseTimeWithMultipleFormats 尝试使用多种格式解析时间字符串
func parseTimeWithMultipleFormats(timeStr string) (time.Time, int, error) {
	// 尝试标准格式
	if t, err := time.Parse("2006-01-02 15:04:05", timeStr); err == nil {
		return t, 0, nil
	}

	// 尝试ISO格式（带时区）
	if t, err := time.Parse(time.RFC3339, timeStr); err == nil {
		return t, 1, nil
	}

	// 尝试ISO格式（不带时区）
	if t, err := time.Parse("2006-01-02T15:04:05", timeStr); err == nil {
		return t, 2, nil
	}

	// 尝试日期格式
	if t, err := time.Parse("2006-01-02", timeStr); err == nil {
		return t, 3, nil
	}

	// 所有格式都失败，返回错误
	return time.Time{}, -1, fmt.Errorf("无法解析时间格式: %s", timeStr)
}
